// gif.worker.js 0.2.0 - https://github.com/jnordberg/gif.js
(function e(t, n, r) {
    function s(o, u) {
        if (!n[o]) {
            if (!t[o]) {
                var a = typeof require === 'function' && require
                if (!u && a) return a(o, !0)
                if (i) return i(o, !0)
                var f = new Error("Cannot find module '" + o + "'")
                throw f.code = 'MODULE_NOT_FOUND',
                f
            }
            var l = n[o] = {
                exports: {}
            }
            t[o][0].call(l.exports, function(e) {
                var n = t[o][1][e]
                return s(n || e)
            }, l, l.exports, e, t, n, r)
        }
        return n[o].exports
    }
    var i = typeof require === 'function' && require
    for (var o = 0; o < r.length; o++) s(r[o])
    return s
})({
    1: [function(require, module, exports) {
        var NeuQuant = require('./TypedNeuQuant.js')
        var LZWEncoder = require('./LZWEncoder.js')

        function ByteArray() {
            this.page = -1
            this.pages = []
            this.newPage()
        }
        ByteArray.pageSize = 4096
        ByteArray.charMap = {}
        for (var i = 0; i < 256; i++) ByteArray.charMap[i] = String.fromCharCode(i)
        ByteArray.prototype.newPage = function() {
            this.pages[++this.page] = new Uint8Array(ByteArray.pageSize)
            this.cursor = 0
        }
        ByteArray.prototype.getData = function() {
            var rv = ''
            for (var p = 0; p < this.pages.length; p++) {
                for (var i = 0; i < ByteArray.pageSize; i++) {
                    rv += ByteArray.charMap[this.pages[p][i]]
                }
            }
            return rv
        }
        ByteArray.prototype.writeByte = function(val) {
            if (this.cursor >= ByteArray.pageSize) this.newPage()
            this.pages[this.page][this.cursor++] = val
        }
        ByteArray.prototype.writeUTFBytes = function(string) {
            for (var l = string.length, i = 0; i < l; i++) this.writeByte(string.charCodeAt(i))
        }
        ByteArray.prototype.writeBytes = function(array, offset, length) {
            for (var l = length || array.length, i = offset || 0; i < l; i++) this.writeByte(array[i])
        }

        function GIFEncoder(width, height) {
            this.width = ~~width
            this.height = ~~height
            this.transparent = null
            this.transIndex = 0
            this.repeat = -1
            this.delay = 0
            this.image = null
            this.pixels = null
            this.indexedPixels = null
            this.colorDepth = null
            this.colorTab = null
            this.neuQuant = null
            this.usedEntry = new Array()
            this.palSize = 7
            this.dispose = -1
            this.firstFrame = true
            this.sample = 10
            this.dither = false
            this.globalPalette = false
            this.out = new ByteArray()
        }
        GIFEncoder.prototype.setDelay = function(milliseconds) {
            this.delay = Math.round(milliseconds / 10)
        }
        GIFEncoder.prototype.setFrameRate = function(fps) {
            this.delay = Math.round(100 / fps)
        }
        GIFEncoder.prototype.setDispose = function(disposalCode) {
            if (disposalCode >= 0) this.dispose = disposalCode
        }
        GIFEncoder.prototype.setRepeat = function(repeat) {
            this.repeat = repeat
        }
        GIFEncoder.prototype.setTransparent = function(color) {
            this.transparent = color
        }
        GIFEncoder.prototype.addFrame = function(imageData) {
            this.image = imageData
            this.colorTab = this.globalPalette && this.globalPalette.slice ? this.globalPalette : null
            this.getImagePixels()
            this.analyzePixels()
            if (this.globalPalette === true) this.globalPalette = this.colorTab
            if (this.firstFrame) {
                this.writeLSD()
                this.writePalette()
                if (this.repeat >= 0) {
                    this.writeNetscapeExt()
                }
            }
            this.writeGraphicCtrlExt()
            this.writeImageDesc()
            if (!this.firstFrame && !this.globalPalette) this.writePalette()
            this.writePixels()
            this.firstFrame = false
        }
        GIFEncoder.prototype.finish = function() {
            this.out.writeByte(59)
        }
        GIFEncoder.prototype.setQuality = function(quality) {
            if (quality < 1) quality = 1
            this.sample = quality
        }
        GIFEncoder.prototype.setDither = function(dither) {
            if (dither === true) dither = 'FloydSteinberg'
            this.dither = dither
        }
        GIFEncoder.prototype.setGlobalPalette = function(palette) {
            this.globalPalette = palette
        }
        GIFEncoder.prototype.getGlobalPalette = function() {
            return this.globalPalette && this.globalPalette.slice && this.globalPalette.slice(0) || this.globalPalette
        }
        GIFEncoder.prototype.writeHeader = function() {
            this.out.writeUTFBytes('GIF89a')
        }
        GIFEncoder.prototype.analyzePixels = function() {
            if (!this.colorTab) {
                this.neuQuant = new NeuQuant(this.pixels, this.sample)
                this.neuQuant.buildColormap()
                this.colorTab = this.neuQuant.getColormap()
            }
            if (this.dither) {
                this.ditherPixels(this.dither.replace('-serpentine', ''), this.dither.match(/-serpentine/) !== null)
            } else {
                this.indexPixels()
            }
            this.pixels = null
            this.colorDepth = 8
            this.palSize = 7
            if (this.transparent !== null) {
                this.transIndex = this.findClosest(this.transparent, true)
            }
        }
        GIFEncoder.prototype.indexPixels = function(imgq) {
            var nPix = this.pixels.length / 3
            this.indexedPixels = new Uint8Array(nPix)
            var k = 0
            for (var j = 0; j < nPix; j++) {
                var index = this.findClosestRGB(this.pixels[k++] & 255, this.pixels[k++] & 255, this.pixels[k++] & 255)
                this.usedEntry[index] = true
                this.indexedPixels[j] = index
            }
        }
        GIFEncoder.prototype.ditherPixels = function(kernel, serpentine) {
            var kernels = {
                FalseFloydSteinberg: [
                    [3 / 8, 1, 0],
                    [3 / 8, 0, 1],
                    [2 / 8, 1, 1]
                ],
                FloydSteinberg: [
                    [7 / 16, 1, 0],
                    [3 / 16, -1, 1],
                    [5 / 16, 0, 1],
                    [1 / 16, 1, 1]
                ],
                Stucki: [
                    [8 / 42, 1, 0],
                    [4 / 42, 2, 0],
                    [2 / 42, -2, 1],
                    [4 / 42, -1, 1],
                    [8 / 42, 0, 1],
                    [4 / 42, 1, 1],
                    [2 / 42, 2, 1],
                    [1 / 42, -2, 2],
                    [2 / 42, -1, 2],
                    [4 / 42, 0, 2],
                    [2 / 42, 1, 2],
                    [1 / 42, 2, 2]
                ],
                Atkinson: [
                    [1 / 8, 1, 0],
                    [1 / 8, 2, 0],
                    [1 / 8, -1, 1],
                    [1 / 8, 0, 1],
                    [1 / 8, 1, 1],
                    [1 / 8, 0, 2]
                ]
            }
            if (!kernel || !kernels[kernel]) {
                throw 'Unknown dithering kernel: ' + kernel
            }
            var ds = kernels[kernel]
            var index = 0
            var height = this.height
            var width = this.width
            var data = this.pixels
            var direction = serpentine ? -1 : 1
            this.indexedPixels = new Uint8Array(this.pixels.length / 3)
            for (var y = 0; y < height; y++) {
                if (serpentine) direction = direction * -1
                for (var x = direction == 1 ? 0 : width - 1, xend = direction == 1 ? width : 0; x !== xend; x += direction) {
                    index = y * width + x
                    var idx = index * 3
                    var r1 = data[idx]
                    var g1 = data[idx + 1]
                    var b1 = data[idx + 2]
                    idx = this.findClosestRGB(r1, g1, b1)
                    this.usedEntry[idx] = true
                    this.indexedPixels[index] = idx
                    idx *= 3
                    var r2 = this.colorTab[idx]
                    var g2 = this.colorTab[idx + 1]
                    var b2 = this.colorTab[idx + 2]
                    var er = r1 - r2
                    var eg = g1 - g2
                    var eb = b1 - b2
                    for (var i = direction == 1 ? 0 : ds.length - 1, end = direction == 1 ? ds.length : 0; i !== end; i += direction) {
                        var x1 = ds[i][1]
                        var y1 = ds[i][2]
                        if (x1 + x >= 0 && x1 + x < width && y1 + y >= 0 && y1 + y < height) {
                            var d = ds[i][0]
                            idx = index + x1 + y1 * width
                            idx *= 3
                            data[idx] = Math.max(0, Math.min(255, data[idx] + er * d))
                            data[idx + 1] = Math.max(0, Math.min(255, data[idx + 1] + eg * d))
                            data[idx + 2] = Math.max(0, Math.min(255, data[idx + 2] + eb * d))
                        }
                    }
                }
            }
        }
        GIFEncoder.prototype.findClosest = function(c, used) {
            return this.findClosestRGB((c & 16711680) >> 16, (c & 65280) >> 8, c & 255, used)
        }
        GIFEncoder.prototype.findClosestRGB = function(r, g, b, used) {
            if (this.colorTab === null) return -1
            if (this.neuQuant && !used) {
                return this.neuQuant.lookupRGB(r, g, b)
            }
            var c = b | g << 8 | r << 16
            var minpos = 0
            var dmin = 256 * 256 * 256
            var len = this.colorTab.length
            for (var i = 0, index = 0; i < len; index++) {
                var dr = r - (this.colorTab[i++] & 255)
                var dg = g - (this.colorTab[i++] & 255)
                var db = b - (this.colorTab[i++] & 255)
                var d = dr * dr + dg * dg + db * db
                if ((!used || this.usedEntry[index]) && d < dmin) {
                    dmin = d
                    minpos = index
                }
            }
            return minpos
        }
        GIFEncoder.prototype.getImagePixels = function() {
            var w = this.width
            var h = this.height
            this.pixels = new Uint8Array(w * h * 3)
            var data = this.image
            var srcPos = 0
            var count = 0
            for (var i = 0; i < h; i++) {
                for (var j = 0; j < w; j++) {
                    this.pixels[count++] = data[srcPos++]
                    this.pixels[count++] = data[srcPos++]
                    this.pixels[count++] = data[srcPos++]
                    srcPos++
                }
            }
        }
        GIFEncoder.prototype.writeGraphicCtrlExt = function() {
            this.out.writeByte(33)
            this.out.writeByte(249)
            this.out.writeByte(4)
            var transp, disp
            if (this.transparent === null) {
                transp = 0
                disp = 0
            } else {
                transp = 1
                disp = 2
            }
            if (this.dispose >= 0) {
                disp = dispose & 7
            }
            disp <<= 2
            this.out.writeByte(0 | disp | 0 | transp)
            this.writeShort(this.delay)
            this.out.writeByte(this.transIndex)
            this.out.writeByte(0)
        }
        GIFEncoder.prototype.writeImageDesc = function() {
            this.out.writeByte(44)
            this.writeShort(0)
            this.writeShort(0)
            this.writeShort(this.width)
            this.writeShort(this.height)
            if (this.firstFrame || this.globalPalette) {
                this.out.writeByte(0)
            } else {
                this.out.writeByte(128 | 0 | 0 | 0 | this.palSize)
            }
        }
        GIFEncoder.prototype.writeLSD = function() {
            this.writeShort(this.width)
            this.writeShort(this.height)
            this.out.writeByte(128 | 112 | 0 | this.palSize)
            this.out.writeByte(0)
            this.out.writeByte(0)
        }
        GIFEncoder.prototype.writeNetscapeExt = function() {
            this.out.writeByte(33)
            this.out.writeByte(255)
            this.out.writeByte(11)
            this.out.writeUTFBytes('NETSCAPE2.0')
            this.out.writeByte(3)
            this.out.writeByte(1)
            this.writeShort(this.repeat)
            this.out.writeByte(0)
        }
        GIFEncoder.prototype.writePalette = function() {
            this.out.writeBytes(this.colorTab)
            var n = 3 * 256 - this.colorTab.length
            for (var i = 0; i < n; i++) this.out.writeByte(0)
        }
        GIFEncoder.prototype.writeShort = function(pValue) {
            this.out.writeByte(pValue & 255)
            this.out.writeByte(pValue >> 8 & 255)
        }
        GIFEncoder.prototype.writePixels = function() {
            var enc = new LZWEncoder(this.width, this.height, this.indexedPixels, this.colorDepth)
            enc.encode(this.out)
        }
        GIFEncoder.prototype.stream = function() {
            return this.out
        }
        module.exports = GIFEncoder
    },
    {
        './LZWEncoder.js': 2,
        './TypedNeuQuant.js': 3
    }],
    2: [function(require, module, exports) {
        var EOF = -1
        var BITS = 12
        var HSIZE = 5003
        var masks = [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535]

        function LZWEncoder(width, height, pixels, colorDepth) {
            var initCodeSize = Math.max(2, colorDepth)
            var accum = new Uint8Array(256)
            var htab = new Int32Array(HSIZE)
            var codetab = new Int32Array(HSIZE)
            var cur_accum; var cur_bits = 0
            var a_count
            var free_ent = 0
            var maxcode
            var clear_flg = false
            var g_init_bits, ClearCode, EOFCode

            function char_out(c, outs) {
                accum[a_count++] = c
                if (a_count >= 254) flush_char(outs)
            }
            function cl_block(outs) {
                cl_hash(HSIZE)
                free_ent = ClearCode + 2
                clear_flg = true
                output(ClearCode, outs)
            }
            function cl_hash(hsize) {
                for (var i = 0; i < hsize; ++i) htab[i] = -1
            }
            function compress(init_bits, outs) {
                var fcode, c, i, ent, disp, hsize_reg, hshift
                g_init_bits = init_bits
                clear_flg = false
                n_bits = g_init_bits
                maxcode = MAXCODE(n_bits)
                ClearCode = 1 << init_bits - 1
                EOFCode = ClearCode + 1
                free_ent = ClearCode + 2
                a_count = 0
                ent = nextPixel()
                hshift = 0
                for (fcode = HSIZE; fcode < 65536; fcode *= 2)++hshift
                hshift = 8 - hshift
                hsize_reg = HSIZE
                cl_hash(hsize_reg)
                output(ClearCode, outs)
                outer_loop: while ((c = nextPixel()) != EOF) {
                    fcode = (c << BITS) + ent
                    i = c << hshift ^ ent
                    if (htab[i] === fcode) {
                        ent = codetab[i]
                        continue
                    } else if (htab[i] >= 0) {
                        disp = hsize_reg - i
                        if (i === 0) disp = 1
                        do {
                            if ((i -= disp) < 0) i += hsize_reg
                            if (htab[i] === fcode) {
                                ent = codetab[i]
                                continue outer_loop
                            }
                        } while (htab[i] >= 0)
                    }
                    output(ent, outs)
                    ent = c
                    if (free_ent < 1 << BITS) {
                        codetab[i] = free_ent++
                        htab[i] = fcode
                    } else {
                        cl_block(outs)
                    }
                }
                output(ent, outs)
                output(EOFCode, outs)
            }
            function encode(outs) {
                outs.writeByte(initCodeSize)
                remaining = width * height
                curPixel = 0
                compress(initCodeSize + 1, outs)
                outs.writeByte(0)
            }
            function flush_char(outs) {
                if (a_count > 0) {
                    outs.writeByte(a_count)
                    outs.writeBytes(accum, 0, a_count)
                    a_count = 0
                }
            }
            function MAXCODE(n_bits) {
                return (1 << n_bits) - 1
            }
            function nextPixel() {
                if (remaining === 0) return EOF
                --remaining
                var pix = pixels[curPixel++]
                return pix & 255
            }
            function output(code, outs) {
                cur_accum &= masks[cur_bits]
                if (cur_bits > 0) cur_accum |= code << cur_bits
                else cur_accum = code
                cur_bits += n_bits
                while (cur_bits >= 8) {
                    char_out(cur_accum & 255, outs)
                    cur_accum >>= 8
                    cur_bits -= 8
                }
                if (free_ent > maxcode || clear_flg) {
                    if (clear_flg) {
                        maxcode = MAXCODE(n_bits = g_init_bits)
                        clear_flg = false
                    } else {
                        ++n_bits
                        if (n_bits == BITS) maxcode = 1 << BITS
                        else maxcode = MAXCODE(n_bits)
                    }
                }
                if (code == EOFCode) {
                    while (cur_bits > 0) {
                        char_out(cur_accum & 255, outs)
                        cur_accum >>= 8
                        cur_bits -= 8
                    }
                    flush_char(outs)
                }
            }
            this.encode = encode
        }
        module.exports = LZWEncoder
    },
    {}],
    3: [function(require, module, exports) {
        var ncycles = 100
        var netsize = 256
        var maxnetpos = netsize - 1
        var netbiasshift = 4
        var intbiasshift = 16
        var intbias = 1 << intbiasshift
        var gammashift = 10
        var gamma = 1 << gammashift
        var betashift = 10
        var beta = intbias >> betashift
        var betagamma = intbias << gammashift - betashift
        var initrad = netsize >> 3
        var radiusbiasshift = 6
        var radiusbias = 1 << radiusbiasshift
        var initradius = initrad * radiusbias
        var radiusdec = 30
        var alphabiasshift = 10
        var initalpha = 1 << alphabiasshift
        var alphadec
        var radbiasshift = 8
        var radbias = 1 << radbiasshift
        var alpharadbshift = alphabiasshift + radbiasshift
        var alpharadbias = 1 << alpharadbshift
        var prime1 = 499
        var prime2 = 491
        var prime3 = 487
        var prime4 = 503
        var minpicturebytes = 3 * prime4

        function NeuQuant(pixels, samplefac) {
            var network
            var netindex
            var bias
            var freq
            var radpower

            function init() {
                network = []
                netindex = new Int32Array(256)
                bias = new Int32Array(netsize)
                freq = new Int32Array(netsize)
                radpower = new Int32Array(netsize >> 3)
                var i, v
                for (i = 0; i < netsize; i++) {
                    v = (i << netbiasshift + 8) / netsize
                    network[i] = new Float64Array([v, v, v, 0])
                    freq[i] = intbias / netsize
                    bias[i] = 0
                }
            }
            function unbiasnet() {
                for (var i = 0; i < netsize; i++) {
                    network[i][0] >>= netbiasshift
                    network[i][1] >>= netbiasshift
                    network[i][2] >>= netbiasshift
                    network[i][3] = i
                }
            }
            function altersingle(alpha, i, b, g, r) {
                network[i][0] -= alpha * (network[i][0] - b) / initalpha
                network[i][1] -= alpha * (network[i][1] - g) / initalpha
                network[i][2] -= alpha * (network[i][2] - r) / initalpha
            }
            function alterneigh(radius, i, b, g, r) {
                var lo = Math.abs(i - radius)
                var hi = Math.min(i + radius, netsize)
                var j = i + 1
                var k = i - 1
                var m = 1
                var p, a
                while (j < hi || k > lo) {
                    a = radpower[m++]
                    if (j < hi) {
                        p = network[j++]
                        p[0] -= a * (p[0] - b) / alpharadbias
                        p[1] -= a * (p[1] - g) / alpharadbias
                        p[2] -= a * (p[2] - r) / alpharadbias
                    }
                    if (k > lo) {
                        p = network[k--]
                        p[0] -= a * (p[0] - b) / alpharadbias
                        p[1] -= a * (p[1] - g) / alpharadbias
                        p[2] -= a * (p[2] - r) / alpharadbias
                    }
                }
            }
            function contest(b, g, r) {
                var bestd = ~(1 << 31)
                var bestbiasd = bestd
                var bestpos = -1
                var bestbiaspos = bestpos
                var i, n, dist, biasdist, betafreq
                for (i = 0; i < netsize; i++) {
                    n = network[i]
                    dist = Math.abs(n[0] - b) + Math.abs(n[1] - g) + Math.abs(n[2] - r)
                    if (dist < bestd) {
                        bestd = dist
                        bestpos = i
                    }
                    biasdist = dist - (bias[i] >> intbiasshift - netbiasshift)
                    if (biasdist < bestbiasd) {
                        bestbiasd = biasdist
                        bestbiaspos = i
                    }
                    betafreq = freq[i] >> betashift
                    freq[i] -= betafreq
                    bias[i] += betafreq << gammashift
                }
                freq[bestpos] += beta
                bias[bestpos] -= betagamma
                return bestbiaspos
            }
            function inxbuild() {
                var i; var j; var p; var q; var smallpos; var smallval; var previouscol = 0
                var startpos = 0
                for (i = 0; i < netsize; i++) {
                    p = network[i]
                    smallpos = i
                    smallval = p[1]
                    for (j = i + 1; j < netsize; j++) {
                        q = network[j]
                        if (q[1] < smallval) {
                            smallpos = j
                            smallval = q[1]
                        }
                    }
                    q = network[smallpos]
                    if (i != smallpos) {
                        j = q[0]
                        q[0] = p[0]
                        p[0] = j
                        j = q[1]
                        q[1] = p[1]
                        p[1] = j
                        j = q[2]
                        q[2] = p[2]
                        p[2] = j
                        j = q[3]
                        q[3] = p[3]
                        p[3] = j
                    }
                    if (smallval != previouscol) {
                        netindex[previouscol] = startpos + i >> 1
                        for (j = previouscol + 1; j < smallval; j++) netindex[j] = i
                        previouscol = smallval
                        startpos = i
                    }
                }
                netindex[previouscol] = startpos + maxnetpos >> 1
                for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos
            }
            function inxsearch(b, g, r) {
                var a, p, dist
                var bestd = 1e3
                var best = -1
                var i = netindex[g]
                var j = i - 1
                while (i < netsize || j >= 0) {
                    if (i < netsize) {
                        p = network[i]
                        dist = p[1] - g
                        if (dist >= bestd) i = netsize
                        else {
                            i++
                            if (dist < 0) dist = -dist
                            a = p[0] - b
                            if (a < 0) a = -a
                            dist += a
                            if (dist < bestd) {
                                a = p[2] - r
                                if (a < 0) a = -a
                                dist += a
                                if (dist < bestd) {
                                    bestd = dist
                                    best = p[3]
                                }
                            }
                        }
                    }
                    if (j >= 0) {
                        p = network[j]
                        dist = g - p[1]
                        if (dist >= bestd) j = -1
                        else {
                            j--
                            if (dist < 0) dist = -dist
                            a = p[0] - b
                            if (a < 0) a = -a
                            dist += a
                            if (dist < bestd) {
                                a = p[2] - r
                                if (a < 0) a = -a
                                dist += a
                                if (dist < bestd) {
                                    bestd = dist
                                    best = p[3]
                                }
                            }
                        }
                    }
                }
                return best
            }
            function learn() {
                var i
                var lengthcount = pixels.length
                var alphadec = 30 + (samplefac - 1) / 3
                var samplepixels = lengthcount / (3 * samplefac)
                var delta = ~~(samplepixels / ncycles)
                var alpha = initalpha
                var radius = initradius
                var rad = radius >> radiusbiasshift
                if (rad <= 1) rad = 0
                for (i = 0; i < rad; i++) radpower[i] = alpha * ((rad * rad - i * i) * radbias / (rad * rad))
                var step
                if (lengthcount < minpicturebytes) {
                    samplefac = 1
                    step = 3
                } else if (lengthcount % prime1 !== 0) {
                    step = 3 * prime1
                } else if (lengthcount % prime2 !== 0) {
                    step = 3 * prime2
                } else if (lengthcount % prime3 !== 0) {
                    step = 3 * prime3
                } else {
                    step = 3 * prime4
                }
                var b, g, r, j
                var pix = 0
                i = 0
                while (i < samplepixels) {
                    b = (pixels[pix] & 255) << netbiasshift
                    g = (pixels[pix + 1] & 255) << netbiasshift
                    r = (pixels[pix + 2] & 255) << netbiasshift
                    j = contest(b, g, r)
                    altersingle(alpha, j, b, g, r)
                    if (rad !== 0) alterneigh(rad, j, b, g, r)
                    pix += step
                    if (pix >= lengthcount) pix -= lengthcount
                    i++
                    if (delta === 0) delta = 1
                    if (i % delta === 0) {
                        alpha -= alpha / alphadec
                        radius -= radius / radiusdec
                        rad = radius >> radiusbiasshift
                        if (rad <= 1) rad = 0
                        for (j = 0; j < rad; j++) radpower[j] = alpha * ((rad * rad - j * j) * radbias / (rad * rad))
                    }
                }
            }
            function buildColormap() {
                init()
                learn()
                unbiasnet()
                inxbuild()
            }
            this.buildColormap = buildColormap

            function getColormap() {
                var map = []
                var index = []
                for (var i = 0; i < netsize; i++) index[network[i][3]] = i
                var k = 0
                for (var l = 0; l < netsize; l++) {
                    var j = index[l]
                    map[k++] = network[j][0]
                    map[k++] = network[j][1]
                    map[k++] = network[j][2]
                }
                return map
            }
            this.getColormap = getColormap
            this.lookupRGB = inxsearch
        }
        module.exports = NeuQuant
    },
    {}],
    4: [function(require, module, exports) {
        var GIFEncoder, renderFrame
        GIFEncoder = require('./GIFEncoder.js')
        renderFrame = function(frame) {
            var encoder, page, stream, transfer
            encoder = new GIFEncoder(frame.width, frame.height)
            if (frame.index === 0) {
                encoder.writeHeader()
            } else {
                encoder.firstFrame = false
            }
            encoder.setTransparent(frame.transparent)
            encoder.setRepeat(frame.repeat)
            encoder.setDelay(frame.delay)
            encoder.setQuality(frame.quality)
            encoder.setDither(frame.dither)
            encoder.setGlobalPalette(frame.globalPalette)
            encoder.addFrame(frame.data)
            if (frame.last) {
                encoder.finish()
            }
            if (frame.globalPalette === true) {
                frame.globalPalette = encoder.getGlobalPalette()
            }
            stream = encoder.stream()
            frame.data = stream.pages
            frame.cursor = stream.cursor
            frame.pageSize = stream.constructor.pageSize
            if (frame.canTransfer) {
                transfer = (function() {
                    var i, len, ref, results
                    ref = frame.data
                    results = []
                    for (i = 0, len = ref.length; i < len; i++) {
                        page = ref[i]
                        results.push(page.buffer)
                    }
                    return results
                }())
                return self.postMessage(frame, transfer)
            } else {
                return self.postMessage(frame)
            }
        }
        self.onmessage = function(event) {
            return renderFrame(event.data)
        }
    },
    {
        './GIFEncoder.js': 1
    }]
}, {}, [4])
// # sourceMappingURL=gif.worker.js.map
